home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / c / etc / RCS / crypt.c,v < prev    next >
Text File  |  1988-08-22  |  8KB  |  430 lines
  1. head     1.2;
  2. access   ;
  3. symbols  ;
  4. locks    ; strict;
  5. comment  @ * @;
  6.  
  7.  
  8. 1.2
  9. date     88.08.22.10.18.30;  author ouster;  state Exp;
  10. branches ;
  11. next     1.1;
  12.  
  13. 1.1
  14. date     88.07.22.08.34.39;  author ouster;  state Exp;
  15. branches ;
  16. next     ;
  17.  
  18.  
  19. desc
  20. @@
  21.  
  22.  
  23. 1.2
  24. log
  25. @File depended on order-of-allocation of statics.  Now it doesn't.
  26. @
  27. text
  28. @#if defined(LIBC_SCCS) && !defined(lint)
  29. static char sccsid[] = "@@(#)crypt.c    5.2 (Berkeley) 3/9/86";
  30. #endif LIBC_SCCS and not lint
  31.  
  32. /*
  33.  * This program implements the
  34.  * Proposed Federal Information Processing
  35.  *  Data Encryption Standard.
  36.  * See Federal Register, March 17, 1975 (40FR12134)
  37.  */
  38.  
  39. /*
  40.  * Initial permutation,
  41.  */
  42. static    char    IP[] = {
  43.     58,50,42,34,26,18,10, 2,
  44.     60,52,44,36,28,20,12, 4,
  45.     62,54,46,38,30,22,14, 6,
  46.     64,56,48,40,32,24,16, 8,
  47.     57,49,41,33,25,17, 9, 1,
  48.     59,51,43,35,27,19,11, 3,
  49.     61,53,45,37,29,21,13, 5,
  50.     63,55,47,39,31,23,15, 7,
  51. };
  52.  
  53. /*
  54.  * Final permutation, FP = IP^(-1)
  55.  */
  56. static    char    FP[] = {
  57.     40, 8,48,16,56,24,64,32,
  58.     39, 7,47,15,55,23,63,31,
  59.     38, 6,46,14,54,22,62,30,
  60.     37, 5,45,13,53,21,61,29,
  61.     36, 4,44,12,52,20,60,28,
  62.     35, 3,43,11,51,19,59,27,
  63.     34, 2,42,10,50,18,58,26,
  64.     33, 1,41, 9,49,17,57,25,
  65. };
  66.  
  67. /*
  68.  * Permuted-choice 1 from the key bits
  69.  * to yield C and D.
  70.  * Note that bits 8,16... are left out:
  71.  * They are intended for a parity check.
  72.  */
  73. static    char    PC1_C[] = {
  74.     57,49,41,33,25,17, 9,
  75.      1,58,50,42,34,26,18,
  76.     10, 2,59,51,43,35,27,
  77.     19,11, 3,60,52,44,36,
  78. };
  79.  
  80. static    char    PC1_D[] = {
  81.     63,55,47,39,31,23,15,
  82.      7,62,54,46,38,30,22,
  83.     14, 6,61,53,45,37,29,
  84.     21,13, 5,28,20,12, 4,
  85. };
  86.  
  87. /*
  88.  * Sequence of shifts used for the key schedule.
  89. */
  90. static    char    shifts[] = {
  91.     1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1,
  92. };
  93.  
  94. /*
  95.  * Permuted-choice 2, to pick out the bits from
  96.  * the CD array that generate the key schedule.
  97.  */
  98. static    char    PC2_C[] = {
  99.     14,17,11,24, 1, 5,
  100.      3,28,15, 6,21,10,
  101.     23,19,12, 4,26, 8,
  102.     16, 7,27,20,13, 2,
  103. };
  104.  
  105. static    char    PC2_D[] = {
  106.     41,52,31,37,47,55,
  107.     30,40,51,45,33,48,
  108.     44,49,39,56,34,53,
  109.     46,42,50,36,29,32,
  110. };
  111.  
  112. /*
  113.  * The C and D arrays used to calculate the key schedule.
  114.  */
  115.  
  116. static    char    C[28];
  117. static    char    D[28];
  118. /*
  119.  * The key schedule.
  120.  * Generated from the key.
  121.  */
  122. static    char    KS[16][48];
  123.  
  124. /*
  125.  * The E bit-selection table.
  126.  */
  127. static    char    E[48];
  128. static    char    e[] = {
  129.     32, 1, 2, 3, 4, 5,
  130.      4, 5, 6, 7, 8, 9,
  131.      8, 9,10,11,12,13,
  132.     12,13,14,15,16,17,
  133.     16,17,18,19,20,21,
  134.     20,21,22,23,24,25,
  135.     24,25,26,27,28,29,
  136.     28,29,30,31,32, 1,
  137. };
  138.  
  139. /*
  140.  * Set up the key schedule from the key.
  141.  */
  142.  
  143. setkey(key)
  144. char *key;
  145. {
  146.     register i, j, k;
  147.     int t;
  148.  
  149.     /*
  150.      * First, generate C and D by permuting
  151.      * the key.  The low order bit of each
  152.      * 8-bit char is not used, so C and D are only 28
  153.      * bits apiece.
  154.      */
  155.     for (i=0; i<28; i++) {
  156.         C[i] = key[PC1_C[i]-1];
  157.         D[i] = key[PC1_D[i]-1];
  158.     }
  159.     /*
  160.      * To generate Ki, rotate C and D according
  161.      * to schedule and pick up a permutation
  162.      * using PC2.
  163.      */
  164.     for (i=0; i<16; i++) {
  165.         /*
  166.          * rotate.
  167.          */
  168.         for (k=0; k<shifts[i]; k++) {
  169.             t = C[0];
  170.             for (j=0; j<28-1; j++)
  171.                 C[j] = C[j+1];
  172.             C[27] = t;
  173.             t = D[0];
  174.             for (j=0; j<28-1; j++)
  175.                 D[j] = D[j+1];
  176.             D[27] = t;
  177.         }
  178.         /*
  179.          * get Ki. Note C and D are concatenated.
  180.          */
  181.         for (j=0; j<24; j++) {
  182.             KS[i][j] = C[PC2_C[j]-1];
  183.             KS[i][j+24] = D[PC2_D[j]-28-1];
  184.         }
  185.     }
  186.  
  187.     for(i=0;i<48;i++)
  188.         E[i] = e[i];
  189. }
  190.  
  191. /*
  192.  * The 8 selection functions.
  193.  * For some reason, they give a 0-origin
  194.  * index, unlike everything else.
  195.  */
  196. static    char    S[8][64] = {
  197.     14, 4,13, 1, 2,15,11, 8, 3,10, 6,12, 5, 9, 0, 7,
  198.      0,15, 7, 4,14, 2,13, 1,10, 6,12,11, 9, 5, 3, 8,
  199.      4, 1,14, 8,13, 6, 2,11,15,12, 9, 7, 3,10, 5, 0,
  200.     15,12, 8, 2, 4, 9, 1, 7, 5,11, 3,14,10, 0, 6,13,
  201.  
  202.     15, 1, 8,14, 6,11, 3, 4, 9, 7, 2,13,12, 0, 5,10,
  203.      3,13, 4, 7,15, 2, 8,14,12, 0, 1,10, 6, 9,11, 5,
  204.      0,14, 7,11,10, 4,13, 1, 5, 8,12, 6, 9, 3, 2,15,
  205.     13, 8,10, 1, 3,15, 4, 2,11, 6, 7,12, 0, 5,14, 9,
  206.  
  207.     10, 0, 9,14, 6, 3,15, 5, 1,13,12, 7,11, 4, 2, 8,
  208.     13, 7, 0, 9, 3, 4, 6,10, 2, 8, 5,14,12,11,15, 1,
  209.     13, 6, 4, 9, 8,15, 3, 0,11, 1, 2,12, 5,10,14, 7,
  210.      1,10,13, 0, 6, 9, 8, 7, 4,15,14, 3,11, 5, 2,12,
  211.  
  212.      7,13,14, 3, 0, 6, 9,10, 1, 2, 8, 5,11,12, 4,15,
  213.     13, 8,11, 5, 6,15, 0, 3, 4, 7, 2,12, 1,10,14, 9,
  214.     10, 6, 9, 0,12,11, 7,13,15, 1, 3,14, 5, 2, 8, 4,
  215.      3,15, 0, 6,10, 1,13, 8, 9, 4, 5,11,12, 7, 2,14,
  216.  
  217.      2,12, 4, 1, 7,10,11, 6, 8, 5, 3,15,13, 0,14, 9,
  218.     14,11, 2,12, 4, 7,13, 1, 5, 0,15,10, 3, 9, 8, 6,
  219.      4, 2, 1,11,10,13, 7, 8,15, 9,12, 5, 6, 3, 0,14,
  220.     11, 8,12, 7, 1,14, 2,13, 6,15, 0, 9,10, 4, 5, 3,
  221.  
  222.     12, 1,10,15, 9, 2, 6, 8, 0,13, 3, 4,14, 7, 5,11,
  223.     10,15, 4, 2, 7,12, 9, 5, 6, 1,13,14, 0,11, 3, 8,
  224.      9,14,15, 5, 2, 8,12, 3, 7, 0, 4,10, 1,13,11, 6,
  225.      4, 3, 2,12, 9, 5,15,10,11,14, 1, 7, 6, 0, 8,13,
  226.  
  227.      4,11, 2,14,15, 0, 8,13, 3,12, 9, 7, 5,10, 6, 1,
  228.     13, 0,11, 7, 4, 9, 1,10,14, 3, 5,12, 2,15, 8, 6,
  229.      1, 4,11,13,12, 3, 7,14,10,15, 6, 8, 0, 5, 9, 2,
  230.      6,11,13, 8, 1, 4,10, 7, 9, 5, 0,15,14, 2, 3,12,
  231.  
  232.     13, 2, 8, 4, 6,15,11, 1,10, 9, 3,14, 5, 0,12, 7,
  233.      1,15,13, 8,10, 3, 7, 4,12, 5, 6,11, 0,14, 9, 2,
  234.      7,11, 4, 1, 9,12,14, 2, 0, 6,10,13,15, 3, 5, 8,
  235.      2, 1,14, 7, 4,10, 8,13,15,12, 9, 0, 3, 5, 6,11,
  236. };
  237.  
  238. /*
  239.  * P is a permutation on the selected combination
  240.  * of the current L and key.
  241.  */
  242. static    char    P[] = {
  243.     16, 7,20,21,
  244.     29,12,28,17,
  245.      1,15,23,26,
  246.      5,18,31,10,
  247.      2, 8,24,14,
  248.     32,27, 3, 9,
  249.     19,13,30, 6,
  250.     22,11, 4,25,
  251. };
  252.  
  253. /*
  254.  * The current block, divided into 2 halves.  "L" refers to the whole
  255.  * array and also to the left half.  "R" refers to the right half.
  256.  */
  257. static char L[64];
  258. #define R (&L[32])
  259. static    char    tempL[32];
  260. static    char    f[32];
  261.  
  262. /*
  263.  * The combination of the key and the input, before selection.
  264.  */
  265. static    char    preS[48];
  266.  
  267. /*
  268.  * The payoff: encrypt a block.
  269.  */
  270.  
  271. encrypt(block, edflag)
  272. char *block;
  273. {
  274.     int i, ii;
  275.     register t, j, k;
  276.  
  277.     /*
  278.      * First, permute the bits in the input
  279.      */
  280.     for (j=0; j<64; j++)
  281.         L[j] = block[IP[j]-1];
  282.     /*
  283.      * Perform an encryption operation 16 times.
  284.      */
  285.     for (ii=0; ii<16; ii++) {
  286.         /*
  287.          * Set direction
  288.          */
  289.         if (edflag)
  290.             i = 15-ii;
  291.         else
  292.             i = ii;
  293.         /*
  294.          * Save the R array,
  295.          * which will be the new L.
  296.          */
  297.         for (j=0; j<32; j++)
  298.             tempL[j] = R[j];
  299.         /*
  300.          * Expand R to 48 bits using the E selector;
  301.          * exclusive-or with the current key bits.
  302.          */
  303.         for (j=0; j<48; j++)
  304.             preS[j] = R[E[j]-1] ^ KS[i][j];
  305.         /*
  306.          * The pre-select bits are now considered
  307.          * in 8 groups of 6 bits each.
  308.          * The 8 selection functions map these
  309.          * 6-bit quantities into 4-bit quantities
  310.          * and the results permuted
  311.          * to make an f(R, K).
  312.          * The indexing into the selection functions
  313.          * is peculiar; it could be simplified by
  314.          * rewriting the tables.
  315.          */
  316.         for (j=0; j<8; j++) {
  317.             t = 6*j;
  318.             k = S[j][(preS[t+0]<<5)+
  319.                 (preS[t+1]<<3)+
  320.                 (preS[t+2]<<2)+
  321.                 (preS[t+3]<<1)+
  322.                 (preS[t+4]<<0)+
  323.                 (preS[t+5]<<4)];
  324.             t = 4*j;
  325.             f[t+0] = (k>>3)&01;
  326.             f[t+1] = (k>>2)&01;
  327.             f[t+2] = (k>>1)&01;
  328.             f[t+3] = (k>>0)&01;
  329.         }
  330.         /*
  331.          * The new R is L ^ f(R, K).
  332.          * The f here has to be permuted first, though.
  333.          */
  334.         for (j=0; j<32; j++)
  335.             R[j] = L[j] ^ f[P[j]-1];
  336.         /*
  337.          * Finally, the new L (the original R)
  338.          * is copied back.
  339.          */
  340.         for (j=0; j<32; j++)
  341.             L[j] = tempL[j];
  342.     }
  343.     /*
  344.      * The output L and R are reversed.
  345.      */
  346.     for (j=0; j<32; j++) {
  347.         t = L[j];
  348.         L[j] = R[j];
  349.         R[j] = t;
  350.     }
  351.     /*
  352.      * The final output
  353.      * gets the inverse permutation of the very original.
  354.      */
  355.     for (j=0; j<64; j++)
  356.         block[j] = L[FP[j]-1];
  357. }
  358.  
  359. char *
  360. crypt(pw,salt)
  361. char *pw;
  362. char *salt;
  363. {
  364.     register i, j, c;
  365.     int temp;
  366.     static char block[66], iobuf[16];
  367.  
  368.     for(i=0; i<66; i++)
  369.         block[i] = 0;
  370.     for(i=0; (c= *pw) && i<64; pw++){
  371.         for(j=0; j<7; j++, i++)
  372.             block[i] = (c>>(6-j)) & 01;
  373.         i++;
  374.     }
  375.     
  376.     setkey(block);
  377.     
  378.     for(i=0; i<66; i++)
  379.         block[i] = 0;
  380.  
  381.     for(i=0;i<2;i++){
  382.         c = *salt++;
  383.         iobuf[i] = c;
  384.         if(c>'Z') c -= 6;
  385.         if(c>'9') c -= 7;
  386.         c -= '.';
  387.         for(j=0;j<6;j++){
  388.             if((c>>j) & 01){
  389.                 temp = E[6*i+j];
  390.                 E[6*i+j] = E[6*i+j+24];
  391.                 E[6*i+j+24] = temp;
  392.                 }
  393.             }
  394.         }
  395.     
  396.     for(i=0; i<25; i++)
  397.         encrypt(block,0);
  398.     
  399.     for(i=0; i<11; i++){
  400.         c = 0;
  401.         for(j=0; j<6; j++){
  402.             c <<= 1;
  403.             c |= block[6*i+j];
  404.             }
  405.         c += '.';
  406.         if(c>'9') c += 7;
  407.         if(c>'Z') c += 6;
  408.         iobuf[i+2] = c;
  409.     }
  410.     iobuf[i+2] = 0;
  411.     if(iobuf[1]==0)
  412.         iobuf[1] = iobuf[0];
  413.     return(iobuf);
  414. }
  415. @
  416.  
  417.  
  418. 1.1
  419. log
  420. @Initial revision
  421. @
  422. text
  423. @d227 2
  424. a228 1
  425.  * The current block, divided into 2 halves.
  426. d230 2
  427. a231 1
  428. static    char    L[32], R[32];
  429. @
  430.